/* @internal */
名域 ts {
    导出 常量 枚举 模块实例状态_ {
        未实例化_ = 0,
        实例化的_ = 1,
        仅常量枚举_ = 2
    }

    接口 活动标签_ {
        名称: 文字;
        跳出目标: 流程标签_;
        继续目标: 流程标签_;
        引用: 真假;
    }

    常量 枚举 容器标志_ {
        无_ = 0,
        是容器_ = 1 << 0,
        是块范围容器_ = 1 << 1,
        是控制流容器_ = 1 << 2,
        是函数族_ = 1 << 3,
        是函数表达式_ = 1 << 4,
        具有本地_ = 1 << 5,
        是接口_ = 1 << 6,
        是结构_ = 1 << 7,
        是结构字面量_ = 1 << 8
    }

    常量 绑定器 = 创建绑定();
    变量 绑定主机_: 类型检查主机_

    导出 函数 绑定源文件(文件: 源文件_, 主机: 类型检查主机_) {
        性能.标记('绑定之前');
        绑定主机_ = 主机
        绑定器(文件);
        性能.标记('绑定之后');
        性能.度量('绑定', '绑定之前', '绑定之后');
    }

    函数 创建绑定(): (文件: 源文件_) => 无值 {
        变量 文件: 源文件_;
        变量 程序名称: 文字;
        变量 父节点: 节点_;
        变量 容器: 节点_;
        变量 块范围容器: 节点_;
        变量 最后一个容器: 节点_;

        变量 当前流程: 流程节点_;
        变量 当前跳出标签: 流程标签_;
        变量 当前继续标签: 流程标签_;
        变量 当前返回标签: 流程标签_;
        变量 当前真标签: 流程标签_;
        变量 当前假标签: 流程标签_;
        变量 预处理假如若是流程: 流程节点_;
        变量 活动标签组: 活动标签_[];
        变量 具有显示返回: 真假;

        变量 符号数量 = 0;

        变量 符号_: { 新建(标志: 符号标志_, 名称: 文字): 符号_ };

        常量 无法到达流程: 流程节点_ = { 标志: 流程标志_.无法到达_ };
        常量 报告不可访问流程: 流程节点_ = { 标志: 流程标志_.无法到达_ };

        函数 创建诊断从节点(n: 节点_, 消息: 诊断信息_, 参数0?: 文字 | 数字, 参数1?: 文字 | 数字, 参数2?: 文字 | 数字): 诊断_ {
            返回 创建诊断从节点在源文件(获取节点的源文件(n) || 文件, n, 消息, 参数0, 参数1, 参数2);
        }

        函数 绑定源文件(f: 源文件_) {
            文件 = f;
            符号数量 = 0;

            符号_ = 对象分配器.获取符号构造器();

            如果 (!文件.本地组) {
                绑定(文件);
                文件.符号数量 = 符号数量;
            }

            文件 = 未定!;
            程序名称 = 未定!;
            父节点 = 未定!;
            容器 = 未定!;
            块范围容器 = 未定!;
            最后一个容器 = 未定!;
            当前流程 = 未定!;
            当前跳出标签 = 未定!;
            当前继续标签 = 未定!;
            当前返回标签 = 未定!;
            当前真标签 = 未定!;
            当前假标签 = 未定!;
            活动标签组 = 未定!;
            具有显示返回 = 未定!;
        }

        返回 绑定源文件;

        函数 创建符号(标志: 符号标志_, 名称: 文字): 符号_ {
            符号数量++;
            返回 新建 符号_(标志, 名称);
        }

        函数 添加声明到符号(符号: 符号_, n: 声明_, 符号标志: 符号标志_) {
            符号.标志 |= 符号标志;

            n.符号 = 符号;

            如果 (!符号.声明组) {
                符号.声明组 = [n];
            }
            否则 {
                符号.声明组.压入(n);
            }

            如果 (符号标志 & 符号标志_.具有成员_ && !符号.成员) {
                符号.成员 = 创建符号表();
            }

            如果 (符号标志 & 符号标志_.值_) {
                常量 值声明_ = 符号.值声明;
                如果 (!值声明_ || (值声明_.种类 !== n.种类)) {
                    符号.值声明 = n;
                }
            }
        }

        函数 获取声明名称(n: 声明_): 文字 | 未定 {

            常量 名称 = ts.获取声明名称(n);

            如果 (名称) {
                如果 (是导入从成员(n) || 是导入成员(n)) {
                    变量 别名 = n.别名
                    如果 (别名) {
                        返回 别名.文本
                    }
                }
                如果 (是属性名称字面量(名称)) {
                    如果 (是程序声明(n)) {
                        如果 (名称.文本 === '启动') {
                            返回 '@启动'
                        }
                        如果 (名称.文本 === '全局') {
                            返回 '@全局'
                        }
                        如果 (文件.文件导入位置 === 模块导入位置种类_.无_) {
                            返回 `@${转换到相对路径(获取目录路径(文件.路径), 绑定主机_.当前源码目录, 正规化路径)}`
                        }
                        如果 (文件.文件导入位置 === 模块导入位置种类_.外部支持库_) {
                            // 去除外部支持库版本目录
                            返回 `@${转换到相对路径(获取目录路径(获取目录路径(文件.路径)), 绑定主机_.当前模块目录, 正规化路径)}`
                        }
                        如果 (文件.文件导入位置 === 模块导入位置种类_.全局支持库_) {
                            返回 `@${转换到相对路径(获取目录路径(文件.路径), 绑定主机_.全局模块目录, 正规化路径)}`
                        }
                    }
                    返回 名称.文本
                }
                返回 未定;
            }

            假如 (n.种类) {
                若是 语法_.导入成员_:
                    返回 (<导入成员_>n).别名 && (<导入成员_>n).别名!.文本 || 获取基文件名称((<导入成员_>n).模块名.文本);
                若是 语法_.函数类型_:
                    返回 '@调用';
                若是 语法_.参数_:
                    常量 函数类型_ = <函数类型节点_>n.父节点;
                    常量 索引 = 函数类型_.参数!.索引位于(n 转为 参数声明_);
                    返回 '@参数' + 索引 转为 文字;
                若是 语法_.取址表达式_:
                    // 这个是不存在的
                    如果 (是实体名称表达式((<取址表达式_>(<任意>n)).算子)) {
                        获取声明名称(<声明_>(<任意>n).算子)
                    }
                    返回 未定
                若是 语法_.返回值声明属性组_:
                    返回 '@返回值'
            }
        }

        函数 获取显示名称(n: 声明_): 文字 {
            返回 是名称声明(n) ? 声明名称转为文本(n.名称!) : 调试_.断言已定于(获取声明名称(n));
        }

        /**
         * Declares a 符号_ for the n and adds it to symbols. Reports errors for conflicting 标识符 names.
         * @param 符号表 - The 符号 table which n will be added to.
         * @param 父符号 - n's 父节点 declaration.
         * @param n - The declaration to be added to the 符号 table
         * @param 包含组 - The 符号标志_ that n has in addition to its declaration 类型 (eg: export, ambient, etc.)
         * @param 排除组 - The 标志 which n cannot be declared alongside in a 符号 table. Used to report forbidden 声明组.
         */
        函数 声明符号(符号表: 符号表_, 父符号: 符号_ | 未定, n: 声明_, 包含组: 符号标志_, 排除组: 符号标志_): 符号_ {
            常量 名称 = 获取声明名称(n);

            变量 符号: 符号_ | 未定;
            如果 (名称 === 未定) {
                符号 = 创建符号(符号标志_.无_, '(失踪)');
            }
            否则 {
                符号 = 符号表.获取(名称);
                如果 (!符号) {
                    符号表.设置(名称, 符号 = 创建符号(符号标志_.无_, 名称));
                }
                否则 如果 (符号.标志 & 排除组) {
                    如果 (是名称声明(n)) {
                        n.名称!.父节点 = n;
                    }
                    变量 消息 = 符号.标志 & 符号标志_.变量_
                        ? 诊断信息_.无法重新声明块范围变量_0
                        : 诊断信息_.重复标识符_0;
                    循环执行(符号.声明组, 声明 => { 文件.绑定诊断信息组.压入(创建诊断从节点(ts.获取声明名称(声明) || 声明, 消息, 获取显示名称(声明))); });

                    文件.绑定诊断信息组.压入(创建诊断从节点(ts.获取声明名称(n) || n, 消息, 获取显示名称(n)));

                    符号 = 创建符号(符号标志_.无_, 名称);
                }
            }

            添加声明到符号(符号, n, 包含组);

            如果 (符号.父符号) {
                调试_.断言(符号.父符号 === 父符号, '现有的符号父节点应匹配一个新的父节点');
            }
            否则 {
                符号.父符号 = 父符号;
            }

            返回 符号;
        }

        函数 绑定容器(n: 节点_, 容器标志: 容器标志_) {
            常量 储存容器 = 容器;
            常量 储存块范围容器 = 块范围容器;
            如果 (容器标志 & 容器标志_.是容器_) {
                容器 = 块范围容器 = n;
                如果 (容器标志 & 容器标志_.具有本地_) {
                    容器.本地组 = 创建符号表();
                }
                添加到容器链(容器);
            }
            否则 如果 (容器标志 & 容器标志_.是块范围容器_) {
                块范围容器 = n;
                块范围容器.本地组 = 未定;
            }
            如果 (容器标志 & 容器标志_.是控制流容器_) {
                常量 储存当前流程 = 当前流程;
                常量 储存中断标签 = 当前跳出标签;
                常量 储存继续标签 = 当前继续标签;
                常量 储存返回标签 = 当前返回标签;
                常量 储存活动标签 = 活动标签组;
                常量 储存具有显示返回 = 具有显示返回;
                常量 是立即调用 = 容器标志 & 容器标志_.是函数表达式_ && !!获取立即调用的函数表达式(n);
                如果 (!是立即调用) {
                    当前流程 = { 标志: 流程标志_.开始_ };
                    如果 (容器标志 & (容器标志_.是函数表达式_ | 容器标志_.是结构字面量_)) {
                        (<流程开始_>当前流程).容器 = <函数表达式_ | 箭头函数_ | 方法声明_>n;
                    }
                }
                当前返回标签 = 是立即调用 ? 创建分支标签() : 未定!;
                当前跳出标签 = 未定!;
                当前继续标签 = 未定!;
                活动标签组 = 未定!;
                具有显示返回 = 为假;
                绑定子(n);
                如果 (!(当前流程.标志 & 流程标志_.无法到达_) && 容器标志 & 容器标志_.是函数族_ && 节点是存在的((<函数族声明_>n).主体)) {
                    n.标志 |= 节点标志_.具有隐式返回_;
                    如果 (具有显示返回) n.标志 |= 节点标志_.具有显示返回_;
                }
                如果 (当前返回标签) {
                    添加前期(当前返回标签, 当前流程);
                    当前流程 = 完成流程标签(当前返回标签);
                }
                如果 (!是立即调用) {
                    当前流程 = 储存当前流程;
                }
                当前跳出标签 = 储存中断标签;
                当前继续标签 = 储存继续标签;
                当前返回标签 = 储存返回标签;
                活动标签组 = 储存活动标签;
                具有显示返回 = 储存具有显示返回;
            }
            否则 {
                绑定子(n);
            }
            容器 = 储存容器;
            块范围容器 = 储存块范围容器;
        }

        函数 绑定子(n: 节点_): 无值 {
            绑定子平台(n);
        }

        函数 绑定每个(ns: 节点数组_<节点_> | 未定) {
            如果 (ns === 未定) {
                返回;
            }
            循环执行(ns, 绑定);
        }

        函数 绑定每个子(n: 节点_) {
            遍历子节点(n, 绑定, 绑定每个);
        }

        函数 绑定子平台(n: 节点_): 无值 {
            如果 (具有JSDoc节点组(n)) {
                循环 (常量 j 属于 n.jsDoc!) {
                    设置父位置(n, j);
                }
            }

            如果 (检查不可访问(n)) {
                绑定每个子(n);
                返回;
            }

            假如 (n.种类) {
                若是 语法_.循环语句_:
                    绑定循环语句(<循环语句_>n);
                    跳出;
                若是 语法_.循环属于语句_:
                    绑定循环位于语句(<循环属于语句_>n);
                    跳出;
                若是 语法_.如果语句_:
                    绑定如果语句(<如果语句_>n);
                    跳出;
                若是 语法_.返回语句_:
                    绑定返回语句(<返回语句_>n);
                    跳出;
                若是 语法_.跳出语句_:
                若是 语法_.继续语句_:
                    绑定跳出或继续语句(<跳出或继续语句_>n);
                    跳出;
                若是 语法_.假如语句_:
                    绑定假如语句(<假如语句_>n);
                    跳出;
                若是 语法_.若是块_:
                    绑定若是块(<若是块_>n);
                    跳出;
                若是 语法_.若是子句_:
                    绑定若是子句(<若是子句_>n);
                    跳出;
                若是 语法_.标签语句_:
                    绑定标签语句(<标签语句_>n);
                    跳出;
                若是 语法_.前缀一元表达式_:
                    绑定前缀一元表达式流程(<前缀一元表达式_>n);
                    跳出;
                若是 语法_.后缀一元表达式_:
                    绑定后缀一元表达式流程(<后缀一元表达式_>n);
                    跳出;
                若是 语法_.二元表达式_:
                    绑定二元表达式流程(<二元表达式_>n);
                    跳出;
                若是 语法_.条件表达式_:
                    绑定条件表达式流程(<条件表达式_>n);
                    跳出;
                若是 语法_.变量声明_:
                    绑定变量声明流程(<变量声明_>n);
                    跳出;
                若是 语法_.调用表达式_:
                    绑定调用流程(<调用表达式_>n);
                    跳出;
                若是 语法_.JsDoc注释_:
                    绑定JSDoc注释(<JSDoc_>n);
                    跳出;
                默认:
                    绑定每个子(n);
                    跳出;
            }
        }

        函数 是收窄表达式(表达式: 表达式_): 真假 {
            假如 (表达式.种类) {
                若是 语法_.标识符_:
                若是 语法_.属性访问表达式_:
                    返回 是可收窄引用(表达式);
                若是 语法_.调用表达式_:
                    返回 具有收窄参数(<调用表达式_>表达式);
                若是 语法_.括号表达式_:
                    返回 是收窄表达式((<括号表达式_>表达式).表达式);
                若是 语法_.二元表达式_:
                    返回 是收窄二元表达式(<二元表达式_>表达式);
                若是 语法_.前缀一元表达式_:
                    返回 (<前缀一元表达式_>表达式).运算符 === 语法_.叹号_ && 是收窄表达式((<前缀一元表达式_>表达式).算子);
            }
            返回 为假;
        }

        函数 是可收窄引用(表达式: 表达式_): 真假 {
            返回 表达式.种类 === 语法_.标识符_ || 表达式.种类 === 语法_.属性访问表达式_ && 是可收窄引用((<属性访问表达式_>表达式).表达式);
        }

        函数 具有收窄参数(表达式: 调用表达式_) {
            如果 (表达式.实参组) {
                循环 (常量 参数 属于 表达式.实参组) {
                    如果 (是可收窄引用(参数)) {
                        返回 为真;
                    }
                }
            }
            如果 (表达式.表达式.种类 === 语法_.属性访问表达式_ && 是可收窄引用((<属性访问表达式_>表达式.表达式).表达式)) {
                返回 为真;
            }
            返回 为假;
        }

        函数 是可收窄位于运算符(左侧: 表达式_, 右侧: 表达式_) {
            返回 是文本字面量族(左侧) && 是收窄表达式(右侧);
        }

        函数 是收窄二元表达式(表达式: 二元表达式_) {
            假如 (表达式.运算符令牌.种类) {
                若是 语法_.等号_:
                    返回 是可收窄引用(表达式.左侧);
                若是 语法_.双等号_:
                若是 语法_.叹号等号_:
                    返回 是可收窄算子(表达式.左侧) || 是可收窄算子(表达式.右侧);
                若是 语法_.位于_:
                    返回 是可收窄位于运算符(表达式.左侧, 表达式.右侧);
                若是 语法_.逗号_:
                    返回 是收窄表达式(表达式.右侧);
            }
            返回 为假;
        }

        函数 是可收窄算子(表达式: 表达式_): 真假 {
            假如 (表达式.种类) {
                若是 语法_.括号表达式_:
                    返回 是可收窄算子((<括号表达式_>表达式).表达式);
                若是 语法_.二元表达式_:
                    假如 ((<二元表达式_>表达式).运算符令牌.种类) {
                        若是 语法_.等号_:
                            返回 是可收窄算子((<二元表达式_>表达式).左侧);
                        若是 语法_.逗号_:
                            返回 是可收窄算子((<二元表达式_>表达式).右侧);
                    }
            }
            返回 是可收窄引用(表达式);
        }

        函数 创建分支标签(): 流程标签_ {
            返回 {
                标志: 流程标志_.分支标签_,
                前面的组: 未定
            };
        }

        函数 创建循环标签(): 流程标签_ {
            返回 {
                标志: 流程标志_.循环标签_,
                前面的组: 未定
            };
        }

        函数 设置流程节点引用(流程: 流程节点_) {
            流程.标志 |= 流程.标志 & 流程标志_.引用的_ ? 流程标志_.共享的_ : 流程标志_.引用的_;
        }

        函数 添加前期(标签: 流程标签_, 前个: 流程节点_): 无值 {
            如果 (!(前个.标志 & 流程标志_.无法到达_) && !包含(标签.前面的组, 前个)) {
                (标签.前面的组 || (标签.前面的组 = [])).压入(前个);
                设置流程节点引用(前个);
            }
        }

        函数 创建流程条件(标志: 流程标志_, 前个: 流程节点_, 表达式: 表达式_ | 未定): 流程节点_ {
            如果 (前个.标志 & 流程标志_.无法到达_) {
                返回 前个;
            }
            如果 (!表达式) {
                返回 标志 & 流程标志_.真条件_ ? 前个 : 无法到达流程;
            }
            如果 (表达式.种类 === 语法_.真_ && 标志 & 流程标志_.假条件_ || 表达式.种类 === 语法_.假_ && 标志 & 流程标志_.真条件_) {
                返回 无法到达流程;
            }
            如果 (!是收窄表达式(表达式)) {
                返回 前个;
            }
            设置流程节点引用(前个);
            返回 { 标志, 表达式, 前个 };
        }

        函数 创建流程假如子句(前个: 流程节点_, 假如语句_: 假如语句_, 子句开始: 数字, 子句结束: 数字): 流程节点_ {
            如果 (!是收窄表达式(假如语句_.表达式)) {
                返回 前个;
            }
            设置流程节点引用(前个);
            返回 { 标志: 流程标志_.假如子句_, 假如语句_, 子句开始, 子句结束, 前个 };
        }

        函数 创建流程赋值(前个: 流程节点_, n: 表达式_ | 变量声明_): 流程节点_ {
            设置流程节点引用(前个);
            返回 { 标志: 流程标志_.赋值_, 前个, n };
        }

        函数 创建流程数组变异(前个: 流程节点_, n: 调用表达式_ | 二元表达式_): 流程节点_ {
            设置流程节点引用(前个);
            返回 { 标志: 流程标志_.数组变异_, 前个, n };
        }

        函数 完成流程标签(流程: 流程标签_): 流程节点_ {
            常量 前面的组 = 流程.前面的组;
            如果 (!前面的组) {
                返回 无法到达流程;
            }
            如果 (前面的组.长度 === 1) {
                返回 前面的组[0];
            }
            返回 流程;
        }

        函数 是条件语句(n: 节点_) {
            常量 父节点 = n.父节点;
            假如 (父节点.种类) {
                若是 语法_.如果语句_:
                    返回 (<如果语句_>父节点).表达式 === n;
                若是 语法_.循环语句_:
                若是 语法_.条件表达式_:
                    返回 (<循环语句_ | 条件表达式_>父节点).条件 === n;
            }
            返回 为假;
        }

        函数 是逻辑表达式(n: 节点_) {
            判断 (为真) {
                如果 (n.种类 === 语法_.括号表达式_) {
                    n = (<括号表达式_>n).表达式;
                }
                否则 如果 (n.种类 === 语法_.前缀一元表达式_ && (<前缀一元表达式_>n).运算符 === 语法_.叹号_) {
                    n = (<前缀一元表达式_>n).算子;
                }
                否则 {
                    返回 n.种类 === 语法_.二元表达式_ && ((<二元表达式_>n).运算符令牌.种类 === 语法_.双且号_ || (<二元表达式_>n).运算符令牌.种类 === 语法_.双或号_);
                }
            }
        }

        函数 是顶级流程表达式(n: 节点_): 真假 {
            判断 (n.父节点.种类 === 语法_.括号表达式_ ||
                n.父节点.种类 === 语法_.前缀一元表达式_ &&
                (<前缀一元表达式_>n.父节点).运算符 === 语法_.叹号_) {
                n = n.父节点;
            }
            返回 !是条件语句(n) && !是逻辑表达式(n.父节点);
        }

        函数 绑定条件(n: 表达式_ | 未定, 真标签: 流程标签_, 假标签: 流程标签_) {
            常量 储存真标签 = 当前真标签;
            常量 储存假标签 = 当前假标签;
            当前真标签 = 真标签;
            当前假标签 = 假标签;
            绑定(n);
            当前真标签 = 储存真标签;
            当前假标签 = 储存假标签;
            如果 (!n || !是逻辑表达式(n)) {
                添加前期(真标签, 创建流程条件(流程标志_.真条件_, 当前流程, n));
                添加前期(假标签, 创建流程条件(流程标志_.假条件_, 当前流程, n));
            }
        }

        函数 绑定迭代语句(n: 语句_, 跳出标签: 流程标签_, 继续标签: 流程标签_): 无值 {
            常量 储存跳出标签 = 当前跳出标签;
            常量 储存继续标签 = 当前继续标签;
            当前跳出标签 = 跳出标签;
            当前继续标签 = 继续标签;
            绑定(n);
            当前跳出标签 = 储存跳出标签;
            当前继续标签 = 储存继续标签;
        }

        函数 绑定循环语句(n: 循环语句_): 无值 {
            常量 预循环标签 = 创建循环标签();
            常量 预体标签 = 创建分支标签();
            常量 后循环标签 = 创建分支标签();
            绑定(n.初始化);
            添加前期(预循环标签, 当前流程);
            当前流程 = 预循环标签;
            绑定条件(n.条件, 预体标签, 后循环标签);
            当前流程 = 完成流程标签(预体标签);
            绑定迭代语句(n.迭代体, 后循环标签, 预循环标签);
            绑定每个(n.增量器);
            添加前期(预循环标签, 当前流程);
            当前流程 = 完成流程标签(后循环标签);
        }

        函数 绑定循环位于语句(n: 循环属于语句_): 无值 {
            常量 预循环标签 = 创建循环标签();
            常量 后循环标签 = 创建分支标签();
            添加前期(预循环标签, 当前流程);
            当前流程 = 预循环标签;
            绑定每个(n.声明组);
            添加前期(后循环标签, 当前流程);
            绑定(n.表达式);
            绑定迭代语句(n.迭代体, 后循环标签, 预循环标签);
            添加前期(预循环标签, 当前流程);
            当前流程 = 完成流程标签(后循环标签);
        }

        函数 绑定如果语句(n: 如果语句_): 无值 {
            常量 然后标签 = 创建分支标签();
            常量 否则标签 = 创建分支标签();
            常量 后如果标签 = 创建分支标签();
            绑定条件(n.表达式, 然后标签, 否则标签);
            当前流程 = 完成流程标签(然后标签);
            绑定(n.然后语句);
            添加前期(后如果标签, 当前流程);
            当前流程 = 完成流程标签(否则标签);
            绑定(n.否则语句);
            添加前期(后如果标签, 当前流程);
            当前流程 = 完成流程标签(后如果标签);
        }

        函数 绑定返回语句(n: 返回语句_): 无值 {
            绑定每个(n.表达式);
            如果 (n.种类 === 语法_.返回语句_) {
                具有显示返回 = 为真;
                如果 (当前返回标签) {
                    添加前期(当前返回标签, 当前流程);
                }
            }
            当前流程 = 无法到达流程;
        }

        函数 查找活动标签(名称: 文字) {
            如果 (活动标签组) {
                循环 (常量 标签 属于 活动标签组) {
                    如果 (标签.名称 === 名称) {
                        返回 标签;
                    }
                }
            }
            返回 未定;
        }

        函数 绑定跳出或继续流程(n: 跳出或继续语句_, 跳出标签: 流程标签_, 继续标签: 流程标签_) {
            常量 流标签 = n.种类 === 语法_.跳出语句_ ? 跳出标签 : 继续标签;
            如果 (流标签) {
                添加前期(流标签, 当前流程);
                当前流程 = 无法到达流程;
            }
        }

        函数 绑定跳出或继续语句(n: 跳出或继续语句_): 无值 {
            绑定(n.标签);
            如果 (n.标签) {
                常量 活动标签 = 查找活动标签(n.标签.文本);
                如果 (活动标签) {
                    活动标签.引用 = 为真;
                    绑定跳出或继续流程(n, 活动标签.跳出目标, 活动标签.继续目标);
                }
            }
            否则 {
                绑定跳出或继续流程(n, 当前跳出标签, 当前继续标签);
            }
        }

        函数 绑定假如语句(n: 假如语句_): 无值 {
            常量 后假如标签 = 创建分支标签();
            绑定(n.表达式);
            常量 储存跳出标签 = 当前跳出标签;
            常量 储存预假如若是流程 = 预处理假如若是流程;
            当前跳出标签 = 后假如标签;
            预处理假如若是流程 = 当前流程;
            绑定(n.若是块);
            添加前期(后假如标签, 当前流程);
            常量 具有默认 = 循环执行(n.若是块.子句组, c => c.种类 === 语法_.默认子句_);
            n.可能是详尽的 = !具有默认 && !后假如标签.前面的组;
            如果 (!具有默认) {
                添加前期(后假如标签, 创建流程假如子句(预处理假如若是流程, n, 0, 0));
            }
            当前跳出标签 = 储存跳出标签;
            预处理假如若是流程 = 储存预假如若是流程;
            当前流程 = 完成流程标签(后假如标签);
        }

        函数 绑定若是块(n: 若是块_): 无值 {
            常量 子句组 = n.子句组;
            变量 失败流程 = 无法到达流程;
            循环 (变量 i = 0; i < 子句组.长度; i++) {
                常量 子句开始 = i;
                判断 (!子句组[i].语句组.长度 && i + 1 < 子句组.长度) {
                    绑定(子句组[i]);
                    i++;
                }
                常量 预若是标签 = 创建分支标签();
                添加前期(预若是标签, 创建流程假如子句(预处理假如若是流程, n.父节点, 子句开始, i + 1));
                添加前期(预若是标签, 失败流程);
                当前流程 = 完成流程标签(预若是标签);
                常量 子句 = 子句组[i];
                绑定(子句);
                失败流程 = 当前流程;
                如果 (!(当前流程.标志 & 流程标志_.无法到达_) && i !== 子句组.长度 - 1) {
                    错误在第一个令牌(子句, 诊断信息_.Fallthrough_case_in_switch);
                }
            }
        }

        函数 绑定若是子句(n: 若是子句_): 无值 {
            常量 储存当前流程 = 当前流程;
            当前流程 = 预处理假如若是流程;
            绑定(n.表达式);
            当前流程 = 储存当前流程;
            绑定每个(n.语句组);
        }

        函数 压入活动标签(名称: 文字, 跳出标签: 流程标签_, 继续标签: 流程标签_): 活动标签_ {
            常量 活动标签: 活动标签_ = {
                名称,
                跳出目标: 跳出标签,
                继续目标: 继续标签,
                引用: 为假
            };
            (活动标签组 || (活动标签组 = [])).压入(活动标签);
            返回 活动标签;
        }

        函数 弹出活动标签() {
            活动标签组.弹出();
        }

        函数 绑定标签语句(n: 标签语句_): 无值 {
            常量 预语句标签 = 创建循环标签();
            常量 后语句标签 = 创建分支标签();
            绑定(n.标签);
            添加前期(预语句标签, 当前流程);
            常量 活动标签 = 压入活动标签(n.标签.文本, 后语句标签, 预语句标签);
            绑定(n.语句);
            弹出活动标签();
            如果 (!活动标签.引用) {
                文件.绑定诊断信息组.压入(创建诊断从节点(n.标签, 诊断信息_.Unused_label));
            }
            如果 (!n.语句) {
                添加前期(后语句标签, 当前流程);
                当前流程 = 完成流程标签(后语句标签);
            }
        }

        函数 绑定解构目标流程(n: 表达式_) {
            如果 (n.种类 === 语法_.二元表达式_ && (<二元表达式_>n).运算符令牌.种类 === 语法_.等号_) {
                绑定赋值标签流程((<二元表达式_>n).左侧);
            }
            否则 {
                绑定赋值标签流程(n);
            }
        }

        函数 绑定赋值标签流程(n: 表达式_) {
            如果 (是可收窄引用(n)) {
                当前流程 = 创建流程赋值(当前流程, n);
            }
            否则 如果 (n.种类 === 语法_.数组字面量表达式_) {
                循环 (常量 e 属于 (<数组字面量表达式_>n).元素) {
                    绑定解构目标流程(e);
                }
            }
            否则 如果 (n.种类 === 语法_.结构字面量表达式_) {

            }
        }

        函数 绑定逻辑表达式(n: 二元表达式_, 真标签: 流程标签_, 假标签: 流程标签_) {
            常量 预右标签 = 创建分支标签();
            如果 (n.运算符令牌.种类 === 语法_.双且号_) {
                绑定条件(n.左侧, 预右标签, 假标签);
            }
            否则 {
                绑定条件(n.左侧, 真标签, 预右标签);
            }
            当前流程 = 完成流程标签(预右标签);
            绑定(n.运算符令牌);
            绑定条件(n.右侧, 真标签, 假标签);
        }

        函数 绑定前缀一元表达式流程(n: 前缀一元表达式_) {
            如果 (n.运算符 === 语法_.叹号_) {
                常量 储存真标签 = 当前真标签;
                当前真标签 = 当前假标签;
                当前假标签 = 储存真标签;
                绑定每个子(n);
                当前假标签 = 当前真标签;
                当前真标签 = 储存真标签;
            }
            否则 {
                绑定每个子(n);
            }
        }

        函数 绑定后缀一元表达式流程(n: 后缀一元表达式_) {
            绑定每个子(n);
            如果 (n.运算符 === 语法_.双加号_ || n.运算符 === 语法_.双减号_) {
                绑定赋值标签流程(n.算子);
            }
        }

        函数 绑定二元表达式流程(n: 二元表达式_) {
            常量 运算符 = n.运算符令牌.种类;
            如果 (运算符 === 语法_.双且号_ || 运算符 === 语法_.双或号_) {
                如果 (是顶级流程表达式(n)) {
                    常量 后表达式标签 = 创建分支标签();
                    绑定逻辑表达式(n, 后表达式标签, 后表达式标签);
                    当前流程 = 完成流程标签(后表达式标签);
                }
                否则 {
                    绑定逻辑表达式(n, 当前真标签, 当前假标签);
                }
            }
            否则 {
                绑定每个子(n);
                如果 (是赋值运算符(运算符) && !是赋值标签(n)) {
                    绑定赋值标签流程(n.左侧);
                    如果 (运算符 === 语法_.等号_ && n.左侧.种类 === 语法_.元素访问表达式_) {
                        常量 元素访问 = <元素访问表达式_>n.左侧;
                        如果 (是可收窄算子(元素访问.表达式)) {
                            当前流程 = 创建流程数组变异(当前流程, n);
                        }
                    }
                }
            }
        }

        函数 绑定条件表达式流程(n: 条件表达式_) {
            常量 真标签 = 创建分支标签();
            常量 假标签 = 创建分支标签();
            常量 后表达式标签 = 创建分支标签();
            绑定条件(n.条件, 真标签, 假标签);
            当前流程 = 完成流程标签(真标签);
            绑定(n.问号);
            绑定(n.当为真);
            添加前期(后表达式标签, 当前流程);
            当前流程 = 完成流程标签(假标签);
            绑定(n.冒号);
            绑定(n.当为假);
            添加前期(后表达式标签, 当前流程);
            当前流程 = 完成流程标签(后表达式标签);
        }

        函数 绑定初始化变量流程(n: 变量声明_) {
            当前流程 = 创建流程赋值(当前流程, n);
        }

        函数 绑定变量声明流程(n: 变量声明_) {
            绑定每个子(n);
            如果 (是循环属于语句(n.父节点.父节点)) {
                绑定初始化变量流程(n);
            }
        }

        函数 绑定JSDoc注释(n: JSDoc_) {
            遍历子节点(n, nn => {
                绑定(nn);
            });
        }

        函数 绑定调用流程(n: 调用表达式_) {
            变量 表达式: 表达式_ = n.表达式;
            判断 (表达式.种类 === 语法_.括号表达式_) {
                表达式 = (<括号表达式_>表达式).表达式;
            }
            如果 (表达式.种类 === 语法_.函数表达式_ || 表达式.种类 === 语法_.箭头函数_) {
                绑定每个(n.类型实参);
                绑定每个(n.实参组);
                绑定(n.表达式);
            }
            否则 {
                绑定每个子(n);
            }
            如果 (n.表达式.种类 === 语法_.属性访问表达式_) {
                常量 属性访问 = <属性访问表达式_>n.表达式;
                如果 (是可收窄算子(属性访问.表达式) && 是压入或推入标识符(属性访问.名称)) {
                    当前流程 = 创建流程数组变异(当前流程, n);
                }
            }
        }

        函数 获取容器标志(n: 节点_): 容器标志_ {
            假如 (n.种类) {
                若是 语法_.结构字面量表达式_:
                若是 语法_.枚举声明_:                
                    返回 容器标志_.是容器_
                若是 语法_.类型声明_:
                若是 语法_.类型别名声明_:                
                    返回 容器标志_.是容器_ |  容器标志_.具有本地_ 
                若是 语法_.接口声明_:
                    返回 容器标志_.是容器_ |  容器标志_.具有本地_ | 容器标志_.是接口_;
                若是 语法_.返回值声明属性组_:
                    返回 容器标志_.是容器_ | 容器标志_.是结构_;
                若是 语法_.结构声明_:
                    返回 容器标志_.是容器_ | 容器标志_.是结构_ | 容器标志_.具有本地_;
                若是 语法_.源文件_:
                    返回 容器标志_.是容器_ | 容器标志_.是控制流容器_ | 容器标志_.具有本地_;
                若是 语法_.程序声明_:
                    返回 容器标志_.是容器_ | 容器标志_.是控制流容器_;
                若是 语法_.方法声明_:
                若是 语法_.函数声明_:
                若是 语法_.创建函数签名_:
                若是 语法_.方法签名_:
                若是 语法_.函数类型_:
                若是 语法_.函数签名_:
                若是 语法_.启动函数声明_:
                若是 语法_.初始函数声明_:
                    返回 容器标志_.是容器_ | 容器标志_.是控制流容器_ | 容器标志_.具有本地_ | 容器标志_.是函数族_;

                若是 语法_.函数表达式_:
                若是 语法_.箭头函数_:
                    返回 容器标志_.是容器_ | 容器标志_.是控制流容器_ | 容器标志_.具有本地_ | 容器标志_.是函数族_ | 容器标志_.是函数表达式_;

                若是 语法_.循环语句_:
                若是 语法_.循环属于语句_:
                若是 语法_.若是块_:
                    返回 容器标志_.是块范围容器_;

                若是 语法_.块_:
                    返回 是函数族(n.父节点) || 是循环语句(n.父节点) || 是循环属于语句(n.父节点) ? 容器标志_.无_ : 容器标志_.是块范围容器_;

            }
            返回 容器标志_.无_;

        }

        函数 添加到容器链(下个: 节点_) {
            如果 (最后一个容器) {
                最后一个容器.下个容器 = 下个;
            }
            最后一个容器 = 下个;
        }

        函数 声明符号并添加到符号表(n: 声明_, 符号标志: 符号标志_, 符号排除: 符号标志_): 符号_ | 未定 {
            如果 (符号标志 & 符号标志_.类型参数_) {
                返回 声明符号(容器.本地组!, /*父节点*/ 未定, n, 符号标志, 符号排除);
            }
            假如 (容器.种类) {
                若是 语法_.源文件_:
                    返回 声明符号(文件.本地组!, /*父节点*/ 未定, n, 符号标志, 符号排除);
                若是 语法_.结构声明_:
                若是 语法_.程序声明_:
                若是 语法_.结构字面量表达式_:
                若是 语法_.接口声明_:
                若是 语法_.返回值声明属性组_:
                若是 语法_.枚举声明_:
                    返回 声明符号(容器.符号.成员!, 容器.符号, n, 符号标志, 符号排除);
                若是 语法_.函数类型_:
                若是 语法_.初始函数声明_:
                若是 语法_.启动函数声明_:
                若是 语法_.方法声明_:
                若是 语法_.方法签名_:
                若是 语法_.函数声明_:
                若是 语法_.函数表达式_:
                若是 语法_.箭头函数_:
                若是 语法_.创建函数签名_:
                若是 语法_.函数签名_:
                    返回 声明符号(容器.本地组!, /*父节点*/ 未定, n, 符号标志, 符号排除);
            }
        }


        函数 绑定匿名声明(n: 声明_, 符号标志: 符号标志_, 名称: 文字) {
            常量 符号 = 创建符号(符号标志, 名称);
            添加声明到符号(符号, n, 符号标志);
        }

        函数 绑定块范围声明(n: 声明_, 符号标志: 符号标志_, 符号排除: 符号标志_) {
            如果 (块范围容器.种类 === 语法_.程序声明_) {
                声明符号(块范围容器.符号.成员!, 块范围容器.符号, n, 符号标志, 符号排除);
            }
            否则 如果 (!块范围容器.本地组) {
                块范围容器.本地组 = 创建符号表();
                添加到容器链(块范围容器);
                声明符号(块范围容器.本地组, /*父节点*/ 未定, n, 符号标志, 符号排除);
            }
            否则 {
                声明符号(块范围容器.本地组, /*父节点*/ 未定, n, 符号标志, 符号排除);
            }
        }

        函数 错误在第一个令牌(n: 节点_, 消息: 诊断信息_, 参数0?: 任意, 参数1?: 任意, 参数2?: 任意) {
            常量 跨度 = 获取令牌在位置的跨度(文件, n.首位);
            文件.绑定诊断信息组.压入(创建文件诊断信息(文件, 跨度.开始, 跨度.长度, 消息, 参数0, 参数1, 参数2));
        }

        函数 绑定(n: 节点_ | 未定): 无值 {
            如果 (!n) {
                返回;
            }
            n.父节点 = 父节点;
            绑定平台(n);
            如果 (n.种类 > 语法_.尾令牌_) {
                常量 储存父节点 = 父节点;
                父节点 = n;
                常量 容器标志 = 获取容器标志(n);
                如果 (容器标志 === 容器标志_.无_) {
                    绑定子(n);
                }
                否则 {
                    绑定容器(n, 容器标志);
                }
                父节点 = 储存父节点;
            }
        }

        函数 绑定平台(n: 节点_) {
            // 绑定平台应该绑定所有声明语句并生成符号
            假如 (n.种类) {
                若是 语法_.属性访问表达式_:
                    如果 (当前流程 && 是可收窄引用(<表达式_>n)) {
                        n.流程节点 = 当前流程;
                    }
                    跳出;
                若是 语法_.程序声明_:
                    程序名称 = `@${(<程序声明_>n).名称.文本}`
                    常量 程序集符号 = 声明符号并添加到符号表(<程序声明_>n, 符号标志_.程序_, 符号标志_.无_);
                    文件.程序集 = 程序集符号!
                    返回 程序集符号
                若是 语法_.结构字面量表达式_:
                    返回 绑定结构字面量表达式(<结构字面量表达式_>n);
                若是 语法_.函数类型_:
                    返回 绑定函数类型(<函数类型节点_>n);
                若是 语法_.函数表达式_:
                若是 语法_.箭头函数_:
                    返回 绑定函数表达式(<函数表达式_ | 箭头函数_>n);
                若是 语法_.参数_:
                    返回 声明符号并添加到符号表(<参数声明_>n, 符号标志_.变量_, 符号标志_.参数排除_);
                若是 语法_.变量声明_:
                    返回 绑定块范围声明(<变量声明_>n, 符号标志_.变量_, 符号标志_.变量排除_);
                若是 语法_.常量声明_:
                    返回 绑定块范围声明(<常量声明_>n, 符号标志_.常量_, 符号标志_.变量排除_);
                若是 语法_.常量列表元素_:
                    返回 绑定块范围声明(<常量列表元素_>n, 符号标志_.常量_, 符号标志_.变量排除_);
                若是 语法_.枚举声明_:
                    返回 绑定块范围声明(<枚举声明_>n, 符号标志_.枚举_, 符号标志_.枚举排除_);
                若是 语法_.属性声明_:
                    返回 绑定属性(<属性声明_>n, 符号标志_.属性_, 符号标志_.属性排除_);
                若是 语法_.枚举成员声明_:
                    返回 绑定属性(<枚举成员声明_>n, 符号标志_.枚举成员_, 符号标志_.枚举成员排除);
                若是 语法_.结构字面量成员表达式_:
                    返回 绑定属性(<结构字面量成员表达式_>n, 符号标志_.属性_, 符号标志_.属性排除_);
                若是 语法_.方法声明_:
                    返回 绑定方法声明(<方法声明_>n);
                若是 语法_.接受者声明_:
                    返回 绑定接受者声明(<接受者声明_>n)
                若是 语法_.方法签名_:
                    返回 绑定属性(<方法签名_>n, 符号标志_.方法签名_, 符号标志_.方法签名排除_);
                若是 语法_.函数声明_:
                    返回 绑定块范围声明(<函数声明_>n, 符号标志_.函数_, 符号标志_.函数排除_);
                若是 语法_.启动函数声明_:
                    返回 绑定启动函数声明(<启动函数声明_>n) //绑定块范围声明(<启动函数声明_>n, 符号标志_.启动函数_, 符号标志_.全部_);
                若是 语法_.初始函数声明_:
                    返回 绑定初始函数声明(<初始函数声明_>n) //绑定块范围声明(<初始函数声明_>n, 符号标志_.初始函数_, 符号标志_.初始函数排除_);
                若是 语法_.创建函数签名_:
                    返回 绑定块范围声明(<创建函数签名_>n, 符号标志_.创建函数签名_, 符号标志_.创建函数排除_);
                若是 语法_.函数签名_:
                    返回 绑定块范围声明(<函数签名_>n, 符号标志_.函数签名_, 符号标志_.函数签名排除_);
                若是 语法_.返回值声明属性组_:
                    如果 ((<返回值声明属性组_>n).声明组 && (<返回值声明属性组_>n).声明组.长度) {
                        返回 绑定块范围声明(<返回值声明属性组_>n, 符号标志_.结构_, 符号标志_.结构排除_);
                    }
                    跳出
                若是 语法_.类型参数声明_:
                    返回 声明符号并添加到符号表(<类型参数声明_>n, 符号标志_.类型参数_, 符号标志_.类型参数排除_);
                若是 语法_.结构声明_:
                    返回 绑定块范围声明(<结构声明_>n, 符号标志_.结构_, 符号标志_.结构排除_);
                若是 语法_.接口声明_:
                    返回 绑定块范围声明(<接口声明_>n, 符号标志_.接口_, 符号标志_.接口排除_);
                若是 语法_.类型别名声明_:
                    返回 绑定块范围声明(<类型别名声明_>n, 符号标志_.类型别名_, 符号标志_.类型别名排除_);
                若是 语法_.类型声明_:
                    返回 绑定块范围声明(<类型声明_>n, 符号标志_.类型声明_, 符号标志_.类型声明排除_);
                若是 语法_.导入成员_:
                若是 语法_.导入从成员_:
                    返回 绑定导入成员(<导入成员_>n, 符号标志_.别名_, 符号标志_.别名排除_);
                默认:
                    如果 (是类型节点(n) && 容器.种类 === 语法_.返回值声明属性组_) {
                        变量 索引 = 获取索引(n)
                        如果 (索引 !== 未定) {
                            变量 符号 = 创建符号(符号标志_.无_, '@返回值_' + 索引)
                            容器.符号!.成员!.设置('@返回值_' + 索引, 符号);
                            符号.父符号 = 容器.符号
                            添加声明到符号(符号, <声明_><任意>n, 符号标志_.属性_)
                            返回 符号
                        }
                    }
            }
        }

        函数 获取索引(n: 类型节点_): 数字 | 未定 {
            变量 父节点 = n.父节点
            如果 (父节点 && 父节点.种类 === 语法_.返回值声明属性组_ && 父节点 === 容器) {
                返回 (<返回值声明属性组_>父节点).声明组.索引位于(n)
            }
        }

        函数 绑定导入成员(n: 导入成员_, 符号标志: 符号标志_, 符号排除: 符号标志_) {
            返回 声明符号(文件.本地组!, /*父节点*/ 未定, n, 符号标志, 符号排除);
        }

        函数 绑定启动函数声明(n: 启动函数声明_) {
            变量 当前程序符号 = 文件.本地组!.获取(程序名称)!
            如果 (!当前程序符号.启动符号) {
                常量 启动符号 = 创建符号(符号标志_.无_, '启动')
                添加声明到符号(启动符号, n, 符号标志_.启动函数_)
                当前程序符号.启动符号 = 启动符号
                返回 启动符号
            }
            // 错误 
            返回 当前程序符号.启动符号

        }

        函数 绑定初始函数声明(n: 初始函数声明_) {
            变量 当前程序符号 = 文件.本地组!.获取(程序名称)!
            如果 (!当前程序符号.初始声明组) {
                当前程序符号.初始声明组 = []
            }
            常量 初始符号 = 创建符号(符号标志_.无_, '初始')
            添加声明到符号(初始符号, n, 符号标志_.初始函数_)
            当前程序符号.初始声明组.压入(初始符号)
            返回 初始符号
        }

        函数 绑定方法声明(n: 方法声明_) {
            变量 接受者类型: 实体名称_ | 标识符_ | 类型节点_ = n.接受者.类型
            如果 (是指针类型节点(接受者类型)) {
                接受者类型 = 接受者类型.基础类型
            }
            如果 (是类型引用节点(接受者类型)) {
                接受者类型 = 接受者类型.类型名
                如果 (是标识符(接受者类型)) {
                    变量 类型名称 = 接受者类型.文本
                    如果 (文件.本地组) {
                        变量 当前程序符号 = 文件.本地组!.获取(程序名称)!
                        如果 (!当前程序符号.方法集合) {
                            当前程序符号.方法集合 = 创建词典(); // 创建符号表();
                        }
                        如果 (!当前程序符号.方法集合.具有(类型名称)) {
                            当前程序符号.方法集合.设置(类型名称, 创建符号表())
                        }
                        常量 当前类型方法符号表 = 当前程序符号.方法集合.获取(类型名称)!
                        返回 声明符号(当前类型方法符号表, 当前程序符号, n, 符号标志_.方法_, 符号标志_.方法排除_);
                    }
                    文件.绑定诊断信息组.压入(创建诊断从节点(n, 诊断信息_.未发现类型声明_0, 类型名称));
                    返回;
                }
                是指针类型节点(接受者类型)
                    ? 文件.绑定诊断信息组.压入(创建诊断从节点(n, 诊断信息_.不能为指针类型声明方法))
                    : 文件.绑定诊断信息组.压入(创建诊断从节点(n, 诊断信息_.声明方法的类型必须在同一源码文件));
                返回;
            }
            文件.绑定诊断信息组.压入(创建诊断从节点(n, 诊断信息_.声明方法的类型必须是一个引用类型));
        }

        函数 绑定接受者声明(n: 接受者声明_) {
            变量 本体符号 = 创建符号(符号标志_.属性_ , '本体')
            添加声明到符号(本体符号, n, 符号标志_.属性_)
            块范围容器.本地组!.设置('本体', 本体符号);
        }

        函数 绑定函数类型(n: 函数类型节点_): 无值 {
            常量 符号 = 创建符号(符号标志_.函数类型_, 获取声明名称(n)!);
            添加声明到符号(符号, n, 符号标志_.函数类型_);
            常量 类型字面量符号 = 创建符号(符号标志_.类型字面量_, '@类型');
            添加声明到符号(类型字面量符号, n, 符号标志_.类型字面量_);
            类型字面量符号.成员 = 创建符号表();
            类型字面量符号.成员.设置(符号.名称, 符号);
        }

        函数 绑定结构字面量表达式(n: 结构字面量表达式_) {
            常量 去重词典 = 创建词典<真假>();
            循环 (常量 属性 属于 n.属性组) {
                常量 现在种类 = 去重词典.获取(属性.名称.文本);
                如果 (!现在种类) {
                    去重词典.设置(属性.名称.文本, 为真);
                    继续;
                }
                常量 跨度 = 获取错误跨度从节点(文件, 属性.名称);
                文件.绑定诊断信息组.压入(创建文件诊断信息(文件, 跨度.开始, 跨度.长度, 诊断信息_.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));

            }
            返回 绑定匿名声明(n, 符号标志_.结构字面量_, '@结构')
        }

        函数 绑定函数表达式(n: 函数表达式_ | 箭头函数_) {
            如果 (当前流程) {
                n.流程节点 = 当前流程;
            }
            常量 绑定名称 = n.名称 ? n.名称.文本 : '@函数';
            返回 绑定匿名声明(n, 符号标志_.函数_, 绑定名称);
        }

        函数 绑定属性(n: 声明_, 符号标志: 符号标志_, 符号排除: 符号标志_) {
            返回 声明符号并添加到符号表(n, 符号标志, 符号排除);
        }

        函数 检查不可访问(n: 节点_): 真假 {
            如果 (!(当前流程.标志 & 流程标志_.无法到达_)) {
                返回 为假;
            }
            如果 (当前流程 === 无法到达流程) {
                常量 报告错误 = 是语句但不是声明(n) && n.种类 !== 语法_.空语句_;

                如果 (报告错误) {
                    当前流程 = 报告不可访问流程;
                    常量 允许无法范围代码 = !(n.标志 & 节点标志_.环境_);
                    如果 (允许无法范围代码) {
                        错误在第一个令牌(n, 诊断信息_.Unreachable_code_detected);
                    }
                }
            }
            返回 为真;
        }
    }

    函数 设置父位置(父节点: 节点_, 子节点: 节点_): 无值 {
        子节点.父节点 = 父节点;
        遍历子节点(子节点, (子的子) => 设置父位置(子节点, 子的子));
    }
}
